Notas prácticas - Hacking 1 para CTF

Este es el curso de introducción a Hacking para practicar en plataformas como HackTheBox, VulnHub y DockerLabs. En caso de no tener un buen nivel en Linux, es recomendable hacer el Curso de Linux 1 para Hacking.

Este curso es preparatorio desde 0 para el EJPT, ECPPTV2, EWPT. Hay mucha practica para este curso y hay que realizar los ejercicos para que se quede grabado los conceptos de cada clase.

Esta publicación tiene los apuntes y notas sobre el tema Hacking de nivel introductorio donde se presenta el siguiente temario:

Índice

Direcciones ipv4-ipv6

Lo primero es ¿Qúe es una dirección IP?, en mi caso en la polybar tengo mi propia dirección IP:

Al igual que podemos verla usando el comando ifconfig o ip a:

Podemos ver 2 interfaces de red, siendo la primera enp3s0 y la lo. Solo vamos a centrarnos en la enp3s0 ahí vemos que pone inet, es la IP privada que nos identifica a nivel de usuario.

¿Qué es una dirección IP?

Es una etiqueta numérica que identifica de manera lógica y jerárquica a una interfaz en la red de un dispositivo que utiliza el protocolo de Internet. Y esto no son más que bits ceros y unos. Y consiste de 4 octetos (4 pares de 8 bits). Podemos ver como los dispositivos cada uno se identifica con una dirección IP.

Para la estructura de una dirección IPv4 tenemos 4 pares de octetos representados en base 10, 198.20.250.1.

Para cada uno de los 4 pares sale un Byte compuesto de 8 Bits (0,1).

Para hacer la conversión podemos hacerlo en Bash:

❯ echo "$(echo "obase=2; 192" | bc).168.0.10"
11000000.168.0.10
❯ echo "$(echo "obase=2; 192" | bc).$(echo "obase=2; 168" | bc).0.10"
11000000.10101000.0.10
❯ echo "$(echo "obase=2; 192" | bc).$(echo "obase=2; 168" | bc).$(echo "obase=2; 0" | bc).10"
11000000.10101000.0.10
❯ echo "$(echo "obase=2; 192" | bc).$(echo "obase=2; 168" | bc).$(echo "obase=2; 0" | bc).$(echo "obase=2; 10" | bc)"
11000000.10101000.0.1010

Y esto es la propia representación de la IP en binario:

¿Cuántas direcciones IP se pueden representar hablando de IPv4?

El computo lo hacemos con:

echo "2^32" | bc ----> Para IPv4
4294967296

echo "2^128" | bc ---> Para IPv6
340282366920938463463374607431768211456

Parece que jamas vamos a llegar a semejante cantidad de direcciones por IPv6, al momento de hacer pentesting en HackTheBox para la enumeración de puertos, identificar la máquina requiere tener la noción de estos conceptos.

Todo esto igual es muy básico pero es importante tenerlo muy claro, pronto se trabajará reconocimiento de equipos a nivel de red. Como breve inciso al hacer el comando ifconfig en inet podremos ver nuestra dirección iPv6.

Direcciones MAC Nic y Oui

Si hacemos ifconfig podemos ver en nuestra interfaz de red enp3s0 donde dice ether

Bueno pues d8:5e:d3:89:80:8b es nuestra dirección MAC.

En redes de computadoras una dirección MAC es un identificador de 48 bits que corresponde de manera única a una tarjeta o dispositivo de red, también se le conoce como dirección física y es “única” ya que hay herramientas como MACchanger que permiten modificar esta dirección.

En cuanto a su estructura respecta podemos dividirlo en 2 grupos. Siendo el primero el OUI Organization Unique Identifier y el segundo NIC Network Interface controller especific.

Visita aquí

Podemos aplicar un pequeño escaneo a nivel de red local para encontrar dispositivos conectados a la red.

¿Cómo sabe que dispositivos encuentra en la red local?

hay una herramienta `macchanger` que puede ayudar en esta identificación:

Esto es gracias al OUI, podemos hacer filtros usando grep

macchanger -l | grep -i arris

Siendo arris la marca de mi router podemos ver:

Hay unas cuantas direcciones OUI para el Router de hogar Arris, y podemos ver que el OUI nos ayuda a identificar a que nos estamos enfrentando y entender los ID de los dispositivos.

En auditorias de redes inalambricas en Hacking Wifi se puede hacer mucho uso de está técnica (La tarjeta de red se coloca en modo monitor, la tarjeta de red se da de baja, se cambia la dirección MAC etc). Por ahora es importante entender las direcciones iPv4 iPv6 y MAC.

Protocolos Comunes UDP, TCP y el famoso Three Way HandShake

Cuando hablamos de protocolos por lo general nos centramos en TCP, UDP, vamos a ver un poquito la diferencia entre estos.

TCP vs UDP

Comenzando con TCP.

Este protocolo esta orientado a conexiones, la gran mayoría de dispositivos lo utilizan para conectarse a través internet.

Así mismo, es uno de los principales protocolos en redes TCP/IP, este protocolo es especial porque proporciona verificación de errores además de garantizar la entrega de datos y que los paquetes se entreguen en el orden en el que fueron enviados.

Todo lo contrario a UDP.

Es un protocolo sin conexión, a diferencia del protocolo TCP éste no garantiza la entrega de datos, ni verifica los errores.

El protocolo UDP envía continuamente datos al destinatario pero sin comprobar que este los recibe.

Normalmente, al hablar de este protocolo TCP se habla del Three Way Handshake y se suele ver al momento de entablar una conexión se suele ver algo como esto:

SYN -> SYN ACK -> ACK

Pero, ¿Qué es esto?

Esto hay que verlo como una comunicación

Imagina que estas con un compañero y quieres comenzar la conversación (Esto lo podríamos considerar como el SYN), el compañero una vez le hablamos y comienza la conversación (Sería SYN ACK) ACK viene de acknowledge, y por último ACK.

Esto puede verse en Wireshark

Lo ideal sería tomar para este ejemplo la interfaz loopback

Vamos a ponernos en escucha con nc en el puerto 4646

Siendo ncat una herramienta que nos permite realizar conexiones de red y trabajar el envío de datos

Tratamos de entablar una conexión a nuestra dirección IP, donde con nc estamos en escucha en el puerto 4646:

Si nos vamos al Wireshark veremos lo siguiente:

Podremos ver en los últimos paquetes el Three Way Handshake, estamos viendo el SYN -> SYN ACK -> ACK. En este caso el SYN representa como intentamos conectarnos a nuestra dirección IP por el puerto 4646, donde se nos responde con el SYN ACK, y luego el ACK.

Cuando estamos en una página web, o nos conectamos a un servicio lo normal es ver este principio que opera por TCP.

Recordar muy importante que un servicio puede estar operando en un puerto pero este puede ser TCP o UDP, quizás otros protocolos. Nosotros como atacantes debemos realizar escaneos para identificar estos servicios con la herramienta NMAP la cual veremos más adelante en profundidad.

Pasando ahora a los servicios, cabe decir que hay infinidad de servicios pero la cantidad de puertos que existen para alojar estos servicios es de 65535, estos puertos vamos a tratar de enumerarlos con la herramienta NMAP y demás, pero entre estos puertos hay algunos de ellos que suelen ser muy comunes a la hora de realizar estos escaneos.

TCP

-> FTP
-> SSH
-> TELNET (Acceder a otra máquina de manera remota)
-> SMTP (Correo Electronico)
-> DNS
-> HTTP
-> HTTPS
-> POP3
139, 445 -> SMB -> Recursos compartidos a nivel de red a nivel de empresa (Hace mucho daño)
-> IMAP

UDP

-> DNS
-> TFTP
-> SNMP

Por UDP no es muy común encontrar tantos puertos pero los puede haber.

El Modelo OSI

El proceso de enviar una solicitud a un servidor es algo similar a enviar un paquete por correo, todos los paquetes enviados desde nuestro PC pasan por unos pocos pasos para llegar al destinatario. Estos pasos es lo que se conoce como Modelo OSI.

El Modelo OSI es un estándar para los protocolos de red, los protocolos no son más que reglas de comunicación que se utilizan para conectar dos o más computadores.

Justamente el Modelo OSI se encarga de juntar estos protocolos en grupos específicos o capas. Cuando hacemos una solicitud a un servicio web está solicitud recorre un largo camino desde nuestra máquina hasta el servidor, normalmente esto es por un cable de Ethernet o por el aire usando redes WiFi pasando por el proveedor de internet ISP hasta que llega al destino.

El servidor devuelve la respuesta por la misma ruta pero ¿Cómo sabe la solicitud que camino tomar?

Tenemos siete capas y el Modelo OSI enumera desde la superior hasta la inferior:

Capas del Modelo OSI

-> Aplicación
-> Presentación
-> Sesión
-> Transporte 
-> Red
-> Datos
-> Física

La primera capa siendo la física sería el camino que recorre el paquete para llegar al destino, esta capa específica los dispositivo como Hubs y los medios de transmisión como los cables de red, donde los datos se transmiten por estos medios y se procesan en la siguiente capa.

La segunda capa siendo la de datos o enlace actúa como inspector, digamos que observa sí el paquete tiene un defecto en su formato y controla el flujo con el que se envían los paquetes, en esta capa se verifican si los paquetes recibido del medio físico presentan algún error y tratar de corregirlos (Por tanto, las capas superiores asumen una transmisión de paquetes sin errores). Cabe destacar que está capa también controla el flujo de datos que se transmite.

La tercera capa siendo la de red verifica el destinatario y remitente del paquete, en caso de que hayan demasiados mensajes para enviar se puede priorizar cuales se enviaran primero (Actúa como una oficina de correos). Aquí es donde esta el direccionamiento IP source/destination.

La cuarta capa presentaría los camiones o reporteros siendo la capa de transporte, garantizando el envío y recepción de paquetes provenientes de la capa tres. Gestiona el transporte de los paquetes garantizando el éxito de envío de paquetes.

La quinta capa la de sesión es la responsable de establecer y terminar la conexión entre Hosts, también se encarga de realizar el establecimiento de sesiones (También brinda registros Logs y algunas tareas de seguridad).

La sexta capa la de presentación es responsable de traducir todos los datos para que los utilice la siguiente capa, desde la conversión de códigos a caracteres, comprensión de datos y cifrado de los mismos.

La última capa siendo la de aplicación, es donde el usuario consume correos electrónicos, transferir archivos, acceder a sitios webs, etc. Aquí encontramos algunos protocolos comunes como HTTP y HTTPs.

Esto viene bastante bien de cara a soporte para identificar errores subiendo desde la primer capa hasta la última.

Subnetting ¿Qué es y cómo se interpreta una mascara de red?

Hemos venido hablando de las mascaras de red, podemos volver a verlo con ifconfig

Esto que pone 255.255.255.0, nos permite a nosotros como atacantes hacernos una idea de como está estructurada la red (Aplicar escaneos a nivel de red para saber que equipos están conectados).

La mejor forma de practicar en este caso es crear una hoja de cálculo.

¿Qué es el Subnetting?

Esto consiste en dividir una red grande, en redes más pequeñas mediante un proceso cauteloso y con planificación previa para no desaprovechar direcciones IPv4.

Vamos a representar la mascara de red 255.255.255.0 en la hoja de calculo.

Lo que estamos viendo para la mascara de red son bits.

Comenzaremos desde 128 e iremos dividiendo entre 2.
La segunda fila la rellenamos de ‘1’ indicando como un True en algebra boolena.

De ¿Dónde proviene el 255?

La formula es:

=(A1*A2)+(B1*B2)+(C1*C2)+(D1*D2)+(E1*E2)+(F1*F2)+(G1*G2)+(H1*H2)

Y hemos dado con la mascara de red, ahora vamos a agregar dos columnas más (una para el CIDR que es un estándar de red para la interpretación de redes y otra para el Total Hosts).

Para el CIDR vamos a contar todas las posiciones donde haya un ‘1’.

=CONCATENATE("/"; COUNTIF(A2:AI2;1))

Subnetting CIDRs y cálculo total de hosts

En función de la mascara de red o el prefijo de red viendo el CIDR ¿Cuántos Hosts se pueden repartir?

Para esto vamos a realizar la operación:

2^⁽Número total de ceros⁾

Eso es porque tenemos 8 ceros:

Ahora solo queda contar la cantidad de hosts:

El total de host pondrá 256, esto sucede porque se cuenta desde el 0 la cantidad de direcciones ip que se pueden asignar, quizás para algunos es más fácil emplear una técnica de resta para hacer los cálculos un poco más comodos:

2^⁽Total de hosts⁾⁻¹

Ejemplo real

El jefe interno de la empresa te dice:

“Como parte del equipo de auditoría interna, se te ha encomendado una tarea prioritaria: analizar y evaluar la seguridad de un segmento de red estratégico que aloja los servidores críticos de bases de datos de la empresa. Este segmento se encuentra en la dirección 10.10.148.25/18. Tu responsabilidad es identificar vulnerabilidades, riesgos potenciales y asegurar que los controles existentes sean adecuados para proteger la integridad y confidencialidad de la información en esta subred.”

Para esto contruimos una pequeña tabla donde tendremos los 32 segmentos de red posibles para hacer más fácil el trabajo de analizar el segmento de red que nos dan.

Subnetting Mascaras de subred tipos de clase e interpretación de prefijos de red

Viene muy bien tener la tablar para entender el segmento donde esté configurada la red.

El total de hosts va incrementendo en x2 a medida que el número de ceros aumenta en la hoja de cálculo de bits

Cuando encontramos un /21 ya sabemos que la mascara es 255.255.248.0, para el ejemplo la respuesta es 255.255.192.0.

Tendremos que pararnos en Clase B, luego ir al CIRD /21 y nos dice que la Subnet es 255.255.x.0. La x la remplazmos por la subnet Mask 248.

Ejemplo

Supongamos que estamos en una auditoria y tenemos la siguiente dirección IP 192.168.1.0/26 y aquí están los dispositivos de red.

Para llenar los campos de red utilizaremos nuestra tabla de subnet.

Vemos que dice /26 por tanto es una Clase C y la subnet mask tiene 192.

Según nuestra tabla de subnet, el Total hosts es de 64, pero debemos realizar una resta ‘-2’ ya que la Network ID y la Broadcast Address son direcciones reservadas, por tanto sería ‘64-2’ para un total de 62 hosts. Siendo la cantidad de IP libres para repartir como nos guste o para auditar.

Subnetting Interpretación de los rangos de red que el cliente nos ofrece para auditar

Es muy importante hacer ejemplos y practicar, llegados a este punto:

La Broadcast Address o dirección de difusión permite enviar paquetes de datos a todos los usuarios de una red local.

Lo recomendable es llenar la tabla y empezar a jugar con direcciones ip:

El 128 se debe a que debemos de saber identificar los rangos de ip, en el caso de 192.168.112.165/25 no podemos empezar en 192.168.0.0 porque nuestra ip termina en .165, por tanto, 255/2 es aproximado a 128. Por eso empezamos desde esa ip para que la broadcast pueda ser la .255.

Para el último ejemplo de 10.10.13.124/19, se comparte la solución:

Subnetting Redes_curiosas_y_casos_particulares

Para las redes curiosas como la 13.13.13.13/13, podemos ver que tiene una mascara 255.248.0.0.

Para calcular rápido podemos hacer uso de la calculadora y hacer lo siguiente:

256 * 256 = 65536 hosts

desde la 13.0.0.0 hasta la 13.0.255.255, antes de llegar a la 13.1.0.0 hay 65536 hosts,
desde la 13.1.0.0 hasta la 13.0.255.255 hay otros 65536 hosts.

524288/65536 = 8

de la 13.0.0.0 hasta la 13.7.255.255, pero como nuestra ip extraña es la 13.13.13.13 hay que tomar el otro rango
de la 13.8.0.0 hasta la 13.15.255.255 terminamos.

Tips de subnetting y cálculo veloz de direccionamiento en redes

En este punto ya sabremos como atender a esta situación cuando un cliente nos de una dirección IP para auditar mediante el uso de CIDR y mascaras de red (Saber el total de hosts, la network ID, y la Broadcast).

Hay una forma rápida para hacer el cálculo.

La idea es con una IP 172.14.15.16/17

Intentar primero representar la ip en binario

echo "obase=2; 172" | bc

10101100.

echo "obase=2; 14" | bc

10101100.00001110.

echo "obase=2; 15" | bc

10101100.00001110.00001111.

echo "obase=2; 16"

10101100.00001110.00001111.00010000

Lo siguiente es averiguar la mascara de red y el network ID
Como el CIDR es /17, los primeros 17bits pertenecen a la red, y los 15 restantes a hosts

así que rellenamos con ‘1’, los primeros 17bits

11111111.11111111.10000000.00000000

Ahora ya tenemos la Mascara de RED.

echo "ibase=2; 11111111" | bc

Nos devuelve un 255, por tanto ya tenemos un 255.255.x.0, para el x que nos falta sería:

echo "ibase=2; 100000000" | bc

Para averiguar el Network ID, hay que aplicar un AND entre la IP en binario y la mascara de red

Cuando haya una coincidencia entre ‘1’ ponemos un ‘1’ de resto 0

10101100.00001110.00001111.00010000 (172.14.15.16)
11111111.11111111.10000000.00000000 (255.255.128.0)
------------------------------------
10101100.00001110.00000000.00000000

172.14.0.0 sería el network ID.

Para la broadcast address tenemos un /17 y es hasta /32.
```
32-17=15
```
Vamos a poner en ‘1’ 15 bits de la ip 172.14.15.16 correspondientes a host:
```
10101110.00001110.01111111.11111111 -> 172.14
```

echo "ibase=2;01111111" -> 127

y 11111111 corresponde a 255.

La broadcast es 172.14.127.255.

Mi Script Subnetting_tool

Comparto aquí mi herramienta para automátizar el proceso de Subnetting desde Bash proporcionando la dirección IP y la NetMask. La publicación de está herramienta aquí .

El proyecto se centra en el desarrollo de un script en Bash para el cálculo de parámetros de red, incluyendo la identificación de la clase de red, el cálculo del ID de red y del rango de hosts. Además, se implementa una función para obtener la representación binaria de una dirección IP y una máscara de red.

El script de Bash consta de varias funciones clave

1. helpPanel: Muestra un panel de ayuda con la descripción de los parámetros esperados.

 function helpPanel(){
    echo -e "\n[!] Uso: $0 -i <ipAddress> -n <netMask>\n"
    echo -e "\ti) Direccion IPv4 para subnet"
    echo -e "\tn) Mascara de red"
    echo -e "\th) Panel de ayuda"
}

2. calculoSubnet: Realiza el cálculo de la clase de red, el ID de red, el rango de hosts y la representación binaria de la IP y la máscara de red.

3. getNetIDRange: Calcula el rango de ID de red, tomando en cuenta la dirección IP, la máscara de red y el incremento deseado.

4. getHostsPerSubnet: Determina la cantidad de hosts por subred basándose en la máscara de red proporcionada.

5. binaryRepresentation: Obtiene la representación binaria de la dirección IP y la máscara de red.

Ejemplo de Uso

./subNet.sh -i 192.168.1.1 -n 255.255.255.0

Este comando calculará la información de red para la dirección IP 192.168.1.1 y la máscara de red 255.255.255.0.

#!/bin/bash
# Autor: liandd (Juan Garcia)
##Colours
greenColour="\e[0;32m"
endColour="\033[0m\e[0m"
redColour="\e[0;31m"
blueColour="\e[0;34m"
yellowColour="\e[0;33m"
purpleColour="\e[0;35m"
turquoiseColour="\e[0;36m"
grayColour="\e[0;37m"

# Ctrl_C
trap ctrl_c INT

function ctrl_c(){
    echo -e "\n\n${redColour}[!] Saliendo...${endColour}\n"
    tput cnorm && exit 1
}

function helpPanel(){
    echo -e "\n${yellowColour}[!]${endColour}${grayColour} Uso: ${endColour}${greenColour}$0${endColour} ${purpleColour}-i${endColour}${blueColour} <ipAddress>${endColour} ${purpleColour}-n${endColour} ${blueColour}<netMask>${endColour}\n"
    echo -e "\t${purpleColour}i)${endColour}${grayColour} Direccion${endColour}${blueColour} IPv4${endColour}${grayColour} para subnet${endColour}"
    echo -e "\t${purpleColour}n)${endColour}${grayColour} Mascara de red${endColour}"
    echo -e "\t${purpleColour}h)${endColour}${grayColour} Panel de ayuda${endColour}"
}

function binaryRepresentation(){
    IFS='.' read -r -a ipOctet <<< "$1"
    IFS='.' read -r -a netOctet <<< "$2"
    local ipBinary=""
    local netBinary=""
    for octet in "${ipOctet[@]}"; do
        binaryOctet=$(echo "obase=2; $octet" | bc)
        binaryOctet=$(printf "%08d" "$binaryOctet")
        ipBinary+="$binaryOctet."
    done 
    ipBinary=${ipBinary%?}
    for octet in "${netOctet[@]}"; do
        binaryOctet=$(echo "obase=2; $octet" | bc)
        binaryOctet=$(printf "%08d" "$binaryOctet")
        netBinary+="$binaryOctet."
    done
    netBinary=${netBinary%?}
    ipBIN=$ipBinary
    netBIN=$netBinary
    echo -e "\n${greenColour}[!]${endColour}${grayColour} Representacion Binaria:${endColour}"
    echo -e "\n${yellowColour}[+]${endColour}${greenColour} IP Address dada: ${endColour}${purpleColour}$(printf '%s.' "${ipBIN}" | sed "s/\.$//")${endColour} "
    echo -e "${yellowColour}[+]${endColour}${turquoiseColour} Mascara de Red: ${endColour}${purpleColour}$(printf '%s.' "${netBIN}" | sed "s/\.$//")${endColour} "
}

function getOctetosMask(){
    mask="$1"
    IFS='.' read -r -a octetosMask <<< "$mask"
    maskEnRango=()
    if [ "${#octetosMask[@]}" -eq 4 ]; then
        for octeto in "${octetosMask[@]}"; do
            if [ "$octeto" == 0 ] || [ "$octeto" == 128 ] || [ "$octeto" == 192 ] || [ "$octeto" == 224 ] || [ "$octeto" == 240 ] || [ "$octeto" == 248 ] || [ "$octeto" == 252 ] || [ "$octeto" == 254 ] || [ "$octeto" == 255 ]; then
                maskEnRango+=("true")
            else
                maskEnRango+=("false")
            fi
        done
        if [ "${maskEnRango[0]}" == "true" ] && [ "${maskEnRango[1]}" == "true" ] && [ "${maskEnRango[2]}" == "true" ] && [ "${maskEnRango[3]}" == "true" ]; then
            return 0
        else
            echo -e "\n${redColour}[!] Mascaras de subnet solo usan${endColour}${greenColour} 2^${endColour}${yellowColour}[${endColour}${turquoiseColour}0${endColour}${grayColour}-${endColour}${turquoiseColour}7${endColour}${yellowColour}]${endColour}${grayColour}.${endColour}${redColour} Ingresa nuevamente la mascara.${endColour}\n\n"
            exit 1
        fi
        else
            echo -e "\n${redColour}[!] Ingresar los cuatro octetos para la mascara de red usando puntos${endColour}\n"
            exit 1
        fi
}

function getOctetosDeIP(){
    ip="$1"
    IFS='.' read -r -a octetosIP <<< "$ip"
    ipEnRango=()
    if [ "${#octetosIP[@]}" -eq 4 ]; then
        for octeto in "${octetosIP[@]}"; do
            if [ "$octeto" -ge 0 ] && [ "$octeto" -le 255 ]; then
                ipEnRango+=("true")
            else
                ipEnRango+=("false")
            fi
        done
        if [ "${ipEnRango[0]}" == "true" ] && [ "${ipEnRango[1]}" == "true" ] && [ "${ipEnRango[2]}" == "true" ] && [ "${ipEnRango[3]}" == "true" ]; then
            return 0
        else
            echo -e "\n${redColour}[!] Solo hay${endColour}${greenColour} 255 bits${endColour}${blueColour} por octeto${endColour}${grayColour}.${endColour}${redColour} Ingresa nuevamente la IP.${endColour}\n\n"
            exit 1
        fi
    else
        echo -e "\n${redColour}[!] Ingresar los cuatro octetos para la IP usando puntos${endColour}\n\n"
        exit 1
    fi
}

function calcularClase(){
    local octetosIP=("${!1}")
    counter=0 
    if [ "${octetosIP[0]}" == 10 ]; then
        counter=1  # Class A Private address blocks
    elif [ "${octetosIP[0]}" == 172 ] && [ "${octetosIP[1]}" -ge 16 ] && [ "${octetosIP[1]}" -le 31 ]; then
        counter=2  # Class B Private address blocks
    elif [ "${octetosIP[0]}" == 192 ] && [ "${octetosIP[1]}" == 168 ]; then
        counter=3  # Class C Private address blocks
    elif [ "${octetosIP[0]}" == 127 ]; then
        counter=4  # Loopback Address Reserved address blocks
    elif [ "${octetosIP[0]}" -ge 0 ] && [ "${octetosIP[0]}" -lt 127 ]; then
        counter=5
    elif [ "${octetosIP[0]}" -gt 127 ] && [ "${octetosIP[0]}" -lt 192 ]; then
        counter=6
    elif [ "${octetosIP[0]}" -gt 191 ] && [ "${octetosIP[0]}" -lt 224 ]; then
        counter=7
    elif [ "${octetosIP[0]}" -gt 223 ] && [ "${octetosIP[0]}" -lt 240 ]; then
        counter=8
    elif [ "${octetosIP[0]}" -gt 239 ] && [ "${octetosIP[0]}" -le 255 ]; then
        counter=9
    else
        counter=0  # Out of Range
    fi
    case $counter in
        1) echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Class:${endColour}${purpleColour} Private block${endColour},${greenColour} Class 'A'${endColour}" ;;
        2) echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Class:${endColour}${purpleColour} Private block${endColour},${greenColour} Class 'B'${endColour}" ;;
        3) echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Class:${endColour}${purpleColour} Private block${endColour},${greenColour} Class 'C'${endColour}" ;;
        4) echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Class:${endColour}${redColour} Reserved block, System Loopback Address${endColour}" ;;
        5) echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Class:${endColour}${greenColour} A${endColour}" ;;
        6) echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Class:${endColour}${greenColour} B${endColour}" ;;
        7) echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Class:${endColour}${greenColour} C${endColour}" ;;
        8) echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Class:${endColour}${greenColour} D${endColour}"
            echo -e "\n${redColour}[!]${endColour}${grayColour} Esta es una ${endColour}${greenColour}Clase D${endColour}${redColour} Reservada${endColour}${turquoiseColour} 'Multicast IP Address Block'${endColour}" ;;
        9) echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Class:${endColour}${greenColour} E${endColour}"
            echo -e "\n${redColour}[!]${endColour}${grayColour} Esta es una ${endColour}${greenColour}Clase E${endColour}${redColour} Reservada${endColour}${turquoiseColour} 'Multicast IP Address Block'${endColour}" ;;
        *) echo -e "\n${redColour}[!]${endColour}${grayColour} No esta en rango${endColour}" ;;
    esac
}

function getNetID(){
    local -n ip_ref=$1
    local -n mask_ref=$2
    netID=()
    for ((j = 0; j < ${#ip_ref[@]}; j++)); do
        netID+=($(( ip_ref[j] & mask_ref[j] )))
    done
}

function getNetIDRange(){
    local -a netIDEnd=() 
    IFS='.' read -r -a decimalNetID <<< "$1"
    local netInc=$2
    IFS='.' read -r -a decimalMask <<< "$3"
    for ((i=0; i<${#decimalNetID[@]}; i++)); do
        if [ "${decimalMask[i]}" -eq 255 ]; then
            netIDEnd+=("${decimalNetID[i]}")
        elif [ "${decimalMask[i]}" -lt 255 ] && [ "${decimalMask[i]}" -gt 0 ]; then
            netIDEnd+=("$(( (decimalNetID[i] | (255 - decimalMask[i])) + netInc - 1))")
        else
            netIDEnd+=("255")
        fi
    done
    echo -e "${yellowColour}[+]${endColour}${grayColour} BroadCast IP: ${endColour}${blueColour}$(printf '%s.' "${netIDEnd[@]}" | sed 's/\.$//')${endColour}"
}

function getHostsPerSubnet(){
    IFS='.' read -r -a decimalMask <<< "$1"
    hostBits=0
    for ((i=0; i<${#decimalMask[@]}; i++)); do
        if [ "${decimalMask[i]}" -eq 255 ]; then
            hostBits=$((hostBits + 0))
            continue
        elif [ "${decimalMask[i]}" -eq 254 ]; then
            hostBits=$((hostBits + 1))
            continue
        elif [ "${decimalMask[i]}" -eq 252 ]; then
            hostBits=$((hostBits + 2))
            continue
        elif [ "${decimalMask[i]}" -eq 248 ]; then
            hostBits=$((hostBits + 3))
            continue
        elif [ "${decimalMask[i]}" -eq 240 ]; then
            hostBits=$((hostBits + 4))
            continue
        elif [ "${decimalMask[i]}" -eq 224 ]; then
            hostBits=$((hostBits + 5))
            continue
        elif [ "${decimalMask[i]}" -eq 192 ]; then
            hostBits=$((hostBits + 6))
            continue
        elif [ "${decimalMask[i]}" -eq 128 ]; then
            hostBits=$((hostBits + 7))
            continue
        elif [ "${decimalMask[i]}" -eq 0 ]; then
            hostBits=$((hostBits + 8))
            continue
        else
            hostBits=0
            break
        fi
    done
    local hostsPerSubnet=$(awk -v bits="$hostBits" 'BEGIN { printf "%.0f", 2 ** bits - 2 }')
    echo -e "${yellowColour}[+]${endColour}${grayColour} Total Hosts:${endColour} ${purpleColour}${hostsPerSubnet}${endColour}"
}

function calculoSubnet(){
    ip=$1
    netMask=$2
    octetosIP=()
    octetosMask=()
    netID=()
    netInc=1
    getOctetosDeIP "$ip"
    IFS='.' read -r -a octetosIP <<< "$ip"
    getOctetosMask "$netMask"
    IFS='.' read -r -a octetosMask <<< "$netMask"
    echo -e "\n${yellowColour}[+]${endColour}${grayColour} Calculo de ${endColour}${turquoiseColour}SubNetting${endColour}${greenColour} Juan Garcia${endColour} ${grayColour}(${endColour}${yellowColour}aka${endColour}${redColour} liandd${endColour}${grayColour})${endColour}"
    echo -e "\n${yellowColour}[+]${endColour}${grayColour} IP Address:${endColour}${blueColour} ${ip}${endColour}"
    echo -e "${yellowColour}[+]${endColour}${grayColour} Mascara de Red:${endColour}${blueColour} ${netMask}${endColour}"
    binaryRepresentation $ip $netMask
    echo -e "\n${greenColour}[!]${endColour}${grayColour} Informacion de Clase de red Respecto al ${endColour}${turquoiseColour}CIDR${endColour}"
    calcularClase octetosIP[@]
    getNetID octetosIP octetosMask
    echo -e "${yellowColour}[+]${endColour}${grayColour} Network ID: ${endColour}${blueColour}$(printf '%s.' "${netID[@]}" | sed 's/\.$//')${endColour}"
    getNetIDRange $ip $netInc $netMask
    getHostsPerSubnet $netMask
}

while getopts "i:n:h" arg; do
    case $arg in
        i) ipAddress=$OPTARG;;
        n) netMask=$OPTARG;;
        h) ;;
    esac
done
if [ $ipAddress ] && [ $netMask ]; then
    calculoSubnet "$ipAddress" "$netMask"
else
    helpPanel
fi

Nmap y sus diferentes modos de uso

Para la fase de reconocimiento nosotros como atacantes debemos tener claro en todo momento es conocer que puertos están abiertos. A través de estos puertos se exponen los servicios y así como dijimos anteriormente tenemos 65535 puertos y por defecto vamos a comenzar los escaneos por el protocolo TCP.

Vamos a comenzar practicando con NMAP y usando la dirección IP de nuestro router:

Podemos hacer el comando route -n y en Gateway tendremos 192.168.0.1.

La herramienta NMAP dispone de múltiples parámetros y con el -p le indicamos los puertos que queremos escanear:

Escribimos nmap
Especificamos los puertos que queremos escanear con -p
Por último siempre colocamos nuestra dirección IP a escanear

nmap -p- 192.168.0.1

Usos del -p

nmap -p22 -> enumera únicamente el puerto 22
nmap -p1-65535 -> enumera todo el rango de puertos
nmap -p1-100 -> enumera del 1 al 100
nmap -p- -> también enumera todo el rango de puertos

Este escaneo puede tardar un poco, y cabe resaltar que los resultados pueden arrojar información relevante de los puertos como lo son sus estados (Abierto, Filtrado, Cerrado).

Para el caso del estado Filtrado (Filtered) es porque nmap no es capaz de distinguir con certeza si el puerto está abierto o filtrado (Sea filtrado por Firewall, etc).

El escaneo va bastante lento, para nuestra suerte Nmap nos ofrece formas de agilizar el escaneo. A menos puertos más rápido y más ágil irá el escaneo.

nmap --top-ports 500 192.168.0.1

Realmente en el primer escaneo no nos interesa que el puerto se encuentre filtrado
Agregar --open solo representará los abiertos.

Para adelantar trabajo podemos usar el -v de Verbose para saber más información en tiempo de ejecución de Nmap los puertos descubiertos.

Puerto descubierto 80, 443, 22, 23, etc.

El ir rápido puede quitarnos precisión en nuestro escaneo, pero mirando la anterior imagen dice Initiating Parallell DNS resolution esto significa que esta aplicando resolución DNS.

La resolución DNS Domain Name System es un sistema para traducir los nombres de los sitios web a números IP. En lugar que acceder por IP entramos por http://google.com entre otros.

En algunas ocasiones lo mejor es siempre remover esta resolución con -n

Fue mucho más rápido en este caso, pero podemos aumentar la velocidad aún más agregando Plantillas de temporizado.

Nmap tiene 5 modos

Paranoico
Sigilso
Amable
Normal
Agresivo
Loco

Así podemos ajustar la velocidad de nuestro escaneo

nmap -p- -T5 --open 192.168.0.1 -v -n

A más lento la plantilla de temporizado más silencioso será el escaneo.

Otro escaneo sería con un tcp connect scan

nmap -p- --open -T5 -sT 192.168.0.1 -v -n

Aquí lo que va a pasar es que se va a establecer el Three Way Handshake

Lanzamos un SYN

SYN -> (RST (cerrado))

Sí el puerto está cerrado nos responderá con un RST Reset paquet, pero si está abierto

SYN -> (RST (cerrado) | SYN/ACK (abierto) -> ACK)

Vamos a analizar con Wireshark este flujo, para ello usando tcpdump nos pondremos en escucha para analizar el trafico:

Dado que el puerto destino ha sido el 22, podemos aplicar un filtro como tcp.port == 22

Podemos ver el filtro y como hemos enviado un SYN, y el router nos responde con SYN ACK, por último concluimos la conexión con ACK, y el RST es porque la conexión ya no se mantiene.

Esto fue para un puerto abierto, pero para uno cerrado?

Hemos intentado con nmap -p134 -sT -v -n 192.168.0.1

Aplicando nuevamente el filtro para el puerto 134 vemos el SYN de nuestro lado y como el puerto está cerrado nos cierra la conexión con RST.

Esto sería todo por el -sT tcp connect scan.

Más parámetros

Otro muy interesante es el -Pn ya que nuestros escaneos por defecto con NMAP es identificar si los hosts están activos y en caso de que estén apagados no procede con el escaneo y te recomienda agregar este parámetro. (Lo hace mediante el protocolo de resolución de direcciones ARP).

De que vaya un poco lento no es un problema ya que aún podemos agilizar mucho más el escaneo.

¿Qué tal un escaneo por UDP?

Para escanear con NMAP los puertos por el protocolo UDP, podemos hacerlo de la siguiente manera:

nmap -sU

Pero va mucho más lento por UDP que por TCP.

nmap --top-ports 500 -sU --open -v -n -Pn 192.168.0.1

Este tipo de combinatorias hacen que vayan mucho más rápido los escaneos

ARP vs NMAP

Hace unas clases trabajamos con arp-scan para identificar equipos que estén ubicados dentro nuestra red local

arp-scan -I enp3s0 --localnet

Digamos que podemos hacerlo con NMAP con el parámetro -sn:

nmap -sn 192.168.0.0/24

Se aplica un barrido con PING mediante trazas ICMP para descubrir Hosts activos.

Debemos indicar el CIDR en el escaneo.

Y en este caso hay 7 equipos y hemos logrado identificar hosts en nuestra red local.

Un pequeño bonus es el parámetro -O pero es muy agresivo y no se recomienda para la identificación de sistema operativo.

Algo que si es de utilidad es identificar la versión y servicio para los puertos usando los parametros -sC -sV.

Nos brinda un poco más de información y esto para identificar versiones vulnerables o vías potenciales para explotar alguna vulnerabilidad y esta genial.

Técnicas de evasión de FireWalls - MTU DATA LENGTH SOURCE PORT DECOY ETC

Un Firewall o Corta fuegos es un sistema de seguridad de red que controla el trafico de red entrante y saliente en función de reglas de seguridad predeterminadas.

Normalmente al enumerar una máquina con NMAP hay una serie de puertos abiertos, una vez conseguido el acceso a la máquina es muy probable que con netstats o ss puede en algunas ocasiones tener la máquina puertos abiertos internos (Es bastante normal que sean únicamente visibles internamente).

Se pueden acceder a estos puertos sin problemas con técnicas como Port Forwarding pero lo veremos más adelante, ahora lo que veremos es al hacer escaneos encontrar puertos Filtrados (Pueda ser porque hay un Firewall que impida que Nmap determine si está abierto o cerrado).

Nmap tiene una serie de parametros que pueden ayudar a eludir posibles Firewalls.

Manual de nmap

-f; --mtu <valor>: Fragmentar paquetes
-D <señuelo1,señuelo2[,ME],..>: Disimular análisis con señuelos
--spoof-mac <dirección-mac/prefijo/nombre de fabricante> : Falsificar la dirección MAC
--badsum: Envíar paquetes con una suma de comprobación TCP/UDP Falsa
-g/--source-port <port>: Utilizar el número de puerto dado
-S: Falsificar dirección IP origen
--data-length

Fragmentación de Paquetes

Comenzando con el -f tenemos la Fragmentación de paquetes. Esto es al momento de realizar el escaneo enviar el paquete con todos los datos correspondientes lo enviamos fragmentado y lo podemos ver con wireshark.

namp -p22 192.168.0.1 -f

De primer vistazo no se ve mucha diferencia pero si capturamos el trafíco con tcpdump:

Ahora abrimos la Captura.cap con wireshark

En este caso el filtro no será por un puerto, sino que por paquetes fragmentados. Para hacer esto escribimos el filtro ip.flags.mf == 1:

Podemos ver el filtro y en INFO dice Fragmented IP protocol.

Estos paquetes luego son re ensamblados (Se envían fragmentados y se re ensamblan para poder identificar el contenido del paquete), podemos ver que dice Reassembled in #48 para poder ver esto debemos quitar el filtro y buscar el #48.

Por TCP si ha tramitado una solicitud para saber si el puerto 22 está abierto, en algunos casos los Firewalls esperan un paquete concreto y el hecho de fragmentar el paquete para puertos abiertos o incluso algunos que estén filtrados ayuda a que de primeras podamos llegar a ver los puertos.

MTU Unidad de transmisión máxima

Esto es un valor el cual puede estar establecido en los Firewalls y normalmente son múltiplos de 8 y al poner un valor inferior al esperado podemos burlar el Firewall.

nmap -p22 192.168.0.1 --mtu 8

Si hacemos un nmap --help

Todos estos son los parámetros que podemos usar para eludir un Firewall o un IDS.

Un IDS es un sistema de detección de intrusiones para evitar accesos no autorizados.

Decoy

El parámetro -D Decoy, es para spoofear direcciones IP al hacer un escaneo. El chiste de este parámetro es que no solo se vea únicamente nuestra dirección IP si no muchas más.

nmap -p22 192.168.0.1 -D 192.168.0.27

Vamos a verlo con wireshark:

IP Router 192.168.0.1
Mi IP 192.168.0.6
IP para el Decoy y burlar un posible Firewall 192.168.0.27
Capturamos el tráfico con tcpdump
Abrimos la captura con wireshark

El puerto destino es el 22, así que aplicamos el filtro tcp.port == 22

Donde esta el Source podemos ver Mi dirección IP 192.168.0.6 pero también la 192.168.0.27. Y hemos hecho que otra dirección IP tramite el paquete al destino (Router) y el caso más practico sería el siguiente:

namp --top-ports 100 192.168.0.1 -D -v -n 192.168.0.2,192.168.0.3,192.168.0.4,192.168.0.5,192.168.0.6,192.168.0.7,192.168.0.8,192.168.0.9,192.168.0.10,192.168.0.11,192.168.0.12,192.168.0.13,192.168.0.14,192.168.0.15,192.168.0.16,192.168.0.17,192.168.0.18,192.168.0.19,192.168.0.20,192.168.0.21,192.168.0.22,192.168.0.23,192.168.0.24,192.168.0.25,192.168.0.26,192.168.0.27,192.168.0.28,192.168.0.29,192.168.0.30,192.168.0.31,192.168.0.32,192.168.0.33,192.168.0.34,192.168.0.35,192.168.0.36,192.168.0.37,192.168.0.38,192.168.0.39,192.168.0.40,192.168.0.41,192.168.0.42,192.168.0.43,192.168.0.44,192.168.0.45,192.168.0.46,192.168.0.47,192.168.0.48,192.168.0.49,192.168.0.50,192.168.0.51,192.168.0.52,192.168.0.53,192.168.0.54,192.168.0.55,192.168.0.56,192.168.0.57,192.168.0.58,192.168.0.59,192.168.0.60,192.168.0.61,192.168.0.62,192.168.0.63,192.168.0.64,192.168.0.65,192.168.0.66,192.168.0.67,192.168.0.68,192.168.0.69,192.168.0.70,192.168.0.71,192.168.0.72,192.168.0.73,192.168.0.74,192.168.0.75,192.168.0.76,192.168.0.77,192.168.0.78,192.168.0.79,192.168.0.80,192.168.0.81,192.168.0.82,192.168.0.83,192.168.0.84,192.168.0.85,192.168.0.86,192.168.0.87,192.168.0.88,192.168.0.89,192.168.0.90,192.168.0.91,192.168.0.92,192.168.0.93,192.168.0.94,192.168.0.95,192.168.0.96,192.168.0.97,192.168.0.98,192.168.0.99,192.168.0.100,192.168.0.101,192.168.0.102,192.168.0.103,192.168.0.104,192.168.0.105,192.168.0.106,192.168.0.107,192.168.0.108

Esto trae sus ventajas por ejemplo determinada IP puede ver algunos puertos o servicios abiertos, entonces el que nosotros falsifiquemos con Decoy estas entradas de origen nos puede permitir ver algunos puertos filtrados como abiertos:

Aquí debemos aplicar un filtro para poder ver en funcionamiento el Decoy ip.dst == 192.168.0.1

Así que como origen podemos ver todos las direcciones IP que colocamos en el Decoy con Nmap.

La gran pregunta aquí es ¿Quién es la IP real que está tramitando esta solicitud? Porque ahora es más complicado y para un IDS es difícil identificarlo.

--Source-port

Algo que se suele realizar también es modificar el puerto de salida:

nmap -p22 --open -T5 -v -n 192.168.0.1

Aislado a los puertos de destino como el 22, están los de salida (Aquí un puerto aleatorio del equipo se abre para poder enviar la solicitud y es automático, pero se puede manipular).

Puerto 22 abierto y abrimos la captura con wireshark

Aplicamos el filtro tcp.port == 22
Y en INFO podemos ver el puerto 44732 el cual es el aleatorio que ha abierto nuestra máquina para tramitar el paquete

En ocasiones el Firewall trata de identificar el Source Port y si detecta dentro de una lista blanca que tiene el puerto 53 o el que corresponda, como nuestro puerto fue el 44732 la solicitud es bloqueada por el Firewall.

Esto lo podemos manipular con --source-port 53

En INFO vemos 53, por tanto hemos podido manipular este puerto aleatorio temporalmente eludiendo en algunos casos el Firewall.

Data-length

Hacemos un NMAP al puerto 22 y lo capturamos con tcpdump para posteriormente abrirlo con wireshark

Y donde pone LENGTH vemos 58, hay que tener en cuenta que algunos Firewalls conocen tamaños de paquetes específicos para ciertas herramientas (Una lista negra ejemplo: “Si el paquete tiene un Length de 58, oye cuidado porque a lo mejor nos están intentando hacer un reconocimiento con nmap”).

Podemos modificarlo con --data-length 21

echo $((58+21))
79

Por alguna razón sale 74, pero la longitud del paquete ha sido alterada.

--spoof-mac

nmap -p22 192.168.0.1 --spoof-mac Dell -Pn

En ciertas ocasiones hay equipos autorizados por la dirección MAC para ciertas comunicaciones entre servicios, por tanto todo se va combinando y podemos volver a usar arp-scan -I enp3s0 --localnet para identificar equipos en la red local y obtener sus direcciones MAC, o incluso con el mismo nmap -sn.

-sS Self Scan

Normal mente se tramita un SYN -> RST (Closed)

SYN ACK (Abierto) -> ACK.

Pero el -sS cierra directamente al conexión:

SYN -> SYN ACK -> RST

Esto evita que se registren Logs ya que por defecto la mayoría de Firewalls conexiones establecidas correctamente. Entonces la conexión es cerrada forzosamente.

Esto agiliza bastante la velocidad del escaneo especialmente con el --min-rate y 5000 paquetes (Así habrá garantía de equipos con puertos abiertos y cerrados)

Así es como damos con la poderosa combinación:

sudo nmap -p- --open -sS --min-rate 5000 -v -n -Pn 192.168.0.1

Fue casi instantáneo el escaneo.

Abrimos wireshark:

Aplicamos el filtro tcp.port == 22
Vemos como la comunicación ha sido (SYN -> SYN ACK -> RST)

Uso de Scripts y Categorias de Nmap para aplicar reconocimiento

Nmap tiene una gran cantidad de scripts programados en .lua, para encontrar estos scripts podemos hacer locate .nse:

Yo recomiendo que antes de usar locate actualizar las bases de datos locales con sudo updatedb:

Todos estos scripts son de nmap y los podemos usar.

Anteriormente vimos como el router tiene el puerto 22 ssh abierto, algo que podemos hacer es usar -sC -sV para lanzar una serie de scripts básicos de reconocimiento y identificar la versión y servicio para el puerto 22.

nmap -p22 -sCV 192.168.0.1

En mi caso tengo un total de 615 scripts

Al utilizar -sC lanzara un pequeño conjunto de scripts, no todos porque sería un escaneo muy agresivo.

Vemos que ha intentado lanzar un script con error por tanto, ha encontrado alguno para intentar y lo ha hecho.

Uno de los scripts que suele lanzar el es ftp-anon.nse y el http-robots.nse

El ftp anon, algunas veces está habilitado el usuario anonymous y podemos conectarnos sin contraseña incluso hasta con capacidad de subida de archivos.
el robots.txt lo único que hace es validar la ruta robots.txt porque trae algunas rutas por defecto de página web.

Pero cuando usamos --script podemos usar uno en concreto por ejemplo el http-enum el cual es un diccionario pequeño como rutas posibles para enumeración de páginas web.

Categorias de Scripts

locate .nse

Así veremos todos los scripts para nmap, pero si hacemos:

locate .nse | xargs grep "categories"

Hay muchas y están repetidas, jugando con expresiones regulares:

Tenemos 15 categorías en total.

Se puede combinar categorías lanzando checkers siendo “vuln and safe”

nmap -p22 192.168.0.1 --script="vuln and safe"

Una máquina que fuese vulnerable al Eternal Blue seguramente al lanzar al puerto 445 reportaría que es vulnerable.

Ejemplo

Creamos un directorio admin
Montamos un servidor web con python python3 -m http.server 80
Podemos saber que servicio esta ocupando un puerto con lsof -i:80

Imaginad que queremos aplicar fuerza bruta para encontrar este directorio admin

nmap -p80 --script http-enum 192.168.0.6

Vemos que ha descubierto el admin.

Escuchamos con tcpdump en la loopback
Lanzamos el servidor web con python
Miramos que el puerto este en uso por python
Ejecutamos el nmap

Revisamos la captura pero tshark:

tshark -r Captura.cap 2>/dev/null

En este punto lo que haremos será aplicar filtros:

Nos quedamos solo con las rutas

Vemos que hay un total de 1092 rutas las que prueba este script:

Nmap - Creación de Custom Scripts en Lua

Vamos a crear un script en lua sencillo

example.nse

-- HEAD --

description = [[
Script de ejemplo que enumera y reporta puertos abiertos por TCP
]]

-- RULE --

portrule = function(host, port)
	return port.protocol == "tcp"
		and port.state == "open"
end
-- ACTION --

action = function(host, port)
	return "This port is open!"
end

Alternativas para la enumeraciñón de puertos usando descriptores de archivo

Hasta ahora hemos estado utilizando la herramienta NMAP, pero como pentester o analista de seguridad viene bien saber formas alternativas de realizar la misma operatoria.

Vamos a crear un script en Bash el cual se encargue de descubrir puertos abiertos con una IP que le pasemos.

portScan.sh:

#!/bin/bash
#Autor: liandd (Juan García)
##Colours
greenColour="\e[0;32m"
endColour="\033[0m\e[0m"
redColour="\e[0;31m"
blueColour="\e[0;34m"
yellowColour="\e[0;33m"
purpleColour="\e[0;35m"
turquoiseColour="\e[0;36m"
grayColour="\e[0;37m"

# Ctrl_c
trap ctrl_c SIGINT

function ctrl_c(){
	echo -e "\n\n${redColour}[!] Saliendo...${endColour}"
	tput cnorm; exit 1
}

declare -a ports=( $(seq 1 65535) )

function checkport(){
  (exec 3<> /dev/tcp/$1/$2) 2>/dev/null

  if [ $? -eq 0 ]; then
    echo -e "\n${yellowColour}[+]${endColour} ${grayColour}Host${endColour} ${blueColour}$1${endColour} - ${grayColour}Port${endColour} ${blueColour}$2${endColour} ${greenColour}(OPEN)${endColour}"
  fi

  exec 3<&-
  exec 3>&-

}

if [ $1 ]; then
  for port in ${ports[@]}; do
    checkport $1 $port $ 
  done
else
  echo -e "\n${yellowColour}[!]${endColour} ${grayColour}Uso:${endColour} ${yellowColour}$0${endColour} ${blueColour}<ip-address>${endColour}\n"
fi

wait

Descubrimiento de archivos en la red local - ARP ICMP

Ya hemos trabajado con las siguientes herramientas para hacer descubrimiento de equipos:

arp-scan -I enp3s0 --localnet por el protocolo de resolución de direcciones ARP.
nmap -sn 192.168.0/24 utilizando Ping Swift o barrido de ping.

Pero también podemos scriptearlo en Bash:

#!/bin/bash
#Autor: liandd (Juan García)
##Colours
greenColour="\e[0;32m"
endColour="\033[0m\e[0m"
redColour="\e[0;31m"
blueColour="\e[0;34m"
yellowColour="\e[0;33m"
purpleColour="\e[0;35m"
turquoiseColour="\e[0;36m"
grayColour="\e[0;37m"

trap ctrl_c SIGINT

function ctrl_c(){
  echo -e "\n\n${redColour}[!] Saliendo...${endColour}\n"
  tput cnorm; exit 1
}

tput civis

for i in $(seq 1 254); do 
  for port in 21 22 23 80 443 445 8080; do
    (echo '' > /dev/tcp/192.168.0.$i/$port) 2>/dev/null && echo -e "\n${yellowColour}[+]${endColour} ${grayColour}Host${endColour} ${blueColour}192.168.0.$i${endColour} - ${greenColour}ACTIVE${endColour} - ${grayColour}Port${endColour} ${blueColour}$port${endColour} ${greenColour}(OPEN)${endColour}" &
  done
done

wait

En caso de trazas ICMP bloqueadas está es una buena forma alternativa.

Masscan

Es mucho más potente que nmap, está herramienta Masscan puede escanear millones de hosts.

Validación de un objetivo - Fijando un Target en HackerOne

En este punto lo mejor será crear una cuenta en HackerOne para hacer Bug Bounty.

Esto es más un proyecto a largo plazo, ya que el objetivo es llegar al rango GURU en HackTheBox.

Descubrimiento de correos electronicos

Para está parte se hará uso de sitios web gratuitos en línea, no profundizaremos mucho en está parte:

https://hunter.io
https://phonebook.cz
Clearbit Connect add-on for Gmail
https://www.verifyemailaddress.org
https://email-checker.net

Reconocimiento de imagenes

PimEyes.com

Enumeración de SubDominios

En https://phonebook.cz también podemos hacer enumeración de subdominios.

Algo que podemos hacer es abusar de la transparencia del certificado SSL (Puede ayudar a ver subdominios) con la herramienta ctfr:

git clone https://github.com/UnaPibaGeek/ctfr

De forma pasiva podremos averiguar subdominios:

1120 Subdominos para facebook, lo mejor es que no estamos haciendo fuerza bruta.

Forma Activa

Mediante la herramienta gobuster:

El parametro que nos interesa es vhost, la diferencia es que aquí si haremos uso de diccionarios y fuerza bruta, -u para la URL, -w para el wordlist y acompañarlo de los diccionarios de SecLists:

Simplemente es clonar el repositorio.

gobuster vhost -u https://tinder.com -w /opt/apps/Tools/SecLists/Discovery/DNS/subdomains-top1million-5000.txt

Y para que vaya más rapido podemos agregar hilos con -t 20

y podemos quitar con grep -v 403:

Credenciales y brechas de seguridad

Es una realidad en la que vivimos que los agentes de amenaza al vulnerar compañías (Venden o filtran) bases de datos con información de los usuarios, internos, y son datos críticos que terceros compran o consiguen para divulgarlo en internet. Dehashed es una página de ejemplo que por 10 dolares te da cceso a este tipo de información. No se profundizará más en este tema, si quieres averiguar si tus cuentas han sido comprometidas visita Have I been Pwn3d?.

Identificación de las tecnologías de una página web

Cuando hablamos de las tecnologías que una página web emplea nos referimos a los lenguajes de programación y las herramientas que se utilizan para desarrollar la web y mantenerla activa. (HTML, CSS, JS, PHP, Frameworks, Bases de datos, herramientas de gestión de contenido CMS, etc). Esta información vale oro en la enumeración.

Desde la página de HackerOne voy a seleccionar alexa.amazon.com, vamos a comenzar con la herramienta whatweb.

whatweb es una herramienta que permite identificar la tecnologías que corren detrás de una página web o de un gestor de contenido.

Suele reportar Fugas de información, o correos electronicos en el HTML.

En este caso no vemos nada, pero si encontráramos JQuery, Tengine, Nginx, Apache, Python nos ayuda con la idea de que tecnologías esta usando la página. Y así veríamos en base a las versiones sus vulnerabilidades.

Otra herramienta es Wappalyzer:

Y aquí si vemos que emplea Next.js, JQuery, Format como gestor de contenido, etc.

Fuzzing - Enumeración de archivos en un servidor web

La etapa de fuzzing es muy importante para la enumeración de rutas en un servidor web, (especialmente en HackTheBox) así conoceremos la rutas y posibles recursos.

Nos hemos ido a otra página miwifi.com

Y para averiguar las rutas usaremos gobuster:

El 301 nos hace un redirect
El 403 corresponde a un Forbidden, el servidor deniega la acción solicitada

Para saber que extensiones hay en la página podemos agregar -x php,html,txt

Otra herramienta muy interesante es fuff:

Visita aquí

git clone https://github.com/ffuf/ffuf
cd ffuf
go build -ldflags “-s -w” .
upx brute ffuf

ffuf -w wordlists -u url -c colored -v verbose -mc filtrar por códigos de estado

Google Dorks - Google Hacking (Los 10 Dorks más usados)

Primeramente debemos hablar de Google Hacking

Cuando hablamos de Google Hacking nos referimos a una técnica en informática que implica el uso de operadores para realizar busquedas.

Iremos a google.es

Sí buscamos tinder.com:

podemos realizar filtros avanzados como site:tinder.com

De esta forma estaríamos forzando a que el navegador solo nos muestre resultados relacionados a tinder.com y recursos bajo este dominio.

Existen muchos más filtros por ejemplo filetype:txt

Es público este recurso y es curioso, también podemos contemplar otros archivos como pdf, csv, .jsons e infinidad de otros archivos. Otro filtro sería intext que es una forma de decir que los resultados de búsqueda no necesariamente deben ser de tinder.com pero si los resultados que tengan la palabra tinder.com

¿Qué implica esto?

El uso de metadatos en algunos archivos:

y con la herramienta exiftool podremos verlos:

Esto para hacer inteligencia y recopilar información es tremendo.

Hay una página que se llama Pentest-Tools y está dedicada a recopilar estos Dorks:

Todo esto es legal porque es información pública.

Identificación y verificación de sistema operativo

Antes habíamos trabajado con nmap y el parámetro -o para identificar el sistema operativo, es muy curioso que al momento de aplicar un reconocimiento de equipos en la red local con el protocolo de resolución de direcciones arp-scan podremos ver las máquinas conectadas a nuestra red local. Si probamos lanzando ping -c 1 a estas direcciones IP podremos resaltar un valor importante para la identificación de sistema operativo.

arp-scan -I enp3s0 --localnet

Para el ttl Time To Live Package, es un valor que indica al destinatario cuanto tiempo debe retener el paquete, estos paquetes son diferentes con respecto a los sistemas operativos.

Visita aquí

En función del valor TTL se puede identificar el sistema operativo.

Las máquinas windows suelen tener 128.
Las máquinas linux suelen tener 64.

Estos valores se pueden modificar pero por defecto son estos.

Notas prácticas - Hacking 1 para CTF

Índice

Direcciones ipv4-ipv6

¿Qué es una dirección IP?

¿Cuántas direcciones IP se pueden representar hablando de IPv4?

Direcciones MAC Nic y Oui

hay una herramienta `macchanger` que puede ayudar en esta identificación:

Protocolos Comunes UDP, TCP y el famoso Three Way HandShake

TCP vs UDP

UDP

El Modelo OSI

Capas del Modelo OSI

Subnetting ¿Qué es y cómo se interpreta una mascara de red?

¿Qué es el Subnetting?

De ¿Dónde proviene el 255?

Subnetting CIDRs y cálculo total de hosts

Ejemplo real

Subnetting Mascaras de subred tipos de clase e interpretación de prefijos de red

Ejemplo

Subnetting Interpretación de los rangos de red que el cliente nos ofrece para auditar

Subnetting Redes_curiosas_y_casos_particulares

Tips de subnetting y cálculo veloz de direccionamiento en redes

Mi Script Subnetting_tool

Ejemplo de Uso

Nmap y sus diferentes modos de uso

Usos del -p

Más parámetros

¿Qué tal un escaneo por UDP?

ARP vs NMAP

Técnicas de evasión de FireWalls - MTU DATA LENGTH SOURCE PORT DECOY ETC

Manual de nmap

Fragmentación de Paquetes

MTU Unidad de transmisión máxima

Decoy

--Source-port

Data-length

--spoof-mac

-sS Self Scan

Uso de Scripts y Categorias de Nmap para aplicar reconocimiento

Categorias de Scripts

Ejemplo

Nmap - Creación de Custom Scripts en Lua

Alternativas para la enumeraciñón de puertos usando descriptores de archivo

Descubrimiento de archivos en la red local - ARP ICMP

Masscan

Validación de un objetivo - Fijando un Target en HackerOne

Descubrimiento de correos electronicos

Reconocimiento de imagenes

Enumeración de SubDominios

Forma Activa

Credenciales y brechas de seguridad

Identificación de las tecnologías de una página web

Fuzzing - Enumeración de archivos en un servidor web

Google Dorks - Google Hacking (Los 10 Dorks más usados)

¿Qué implica esto?

Identificación y verificación de sistema operativo

Docker - Introducción

Docker - Instalación

Docker - Definiendo la estructura básica de DockerFile

Docker - Creación y construcción de imagenes

Docker - Carga de instrucciones y despliegue de nuestro primer contenedor

Docker - Comandos comunes para la gestión de contenedores

Docker - Port Forwarding y uso de monturas

Docker - Despligue de máquinas vulnerables con DockerCompose

Enumeración - Servicio FTP

Enumeración - Servicio SSH

Enumeración - Servicio HTTP HTTPS

Enumeración - Servicio SMB

Enumeración - Servicio de Gestores de Contenido CMS WordPress

Enumeración - Servicio de Gestores de Contenido CMS Joomla

Enumeración - Servicio de Gestores de Contenido CMS Drupal

Enumeración - Servicio de Gestores de Contenido CMS Magento

Explotación - Introdución a explotación de vulnerabilidades

Explotación - Reverse Shell, Bind Shells, Forward Shells

Explotación - Tipos de Payloads STAGED NON STAGED

Explotación - Manuales y Automatizadas

Explotación - Enumeración del sistema

Explotación - Introducción a BurpSuite

OWASP TOP 10 - SQLI SQL Injection

OWASP TOP 10 - XXS Cross Site Scripting